{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run the following from the cs231n directory and try again:\n",
      "python setup.py build_ext --inplace\n",
      "You may also need to restart your iPython kernel\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: foward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:\n",
    "\n",
    "---\n",
    "公式：\n",
    "$$\n",
    "Y = X\\cdot w + b\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769847728806635e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking.\n",
    "\n",
    "---\n",
    "公式：\n",
    "$$\n",
    "dX = dY\\cdot w^T\\\\\n",
    "dw = X^T\\cdot dY\\\\\n",
    "db = \\sum_{axis=0}{dY}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:\n",
    "\n",
    "---\n",
    "ReLU层：合页函数，将负值置为零"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:\n",
    "\n",
    "---\n",
    "输入X中非负元素才能接收到上层传递的导数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "1. Sigmoid：输入值的绝对值很大时，梯度接近于0\n",
    "2. ReLU：输入值小于0时，梯度为0\n",
    "3. Leaky ReLU：不存在梯度为0的情况\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  6.750562121603446e-11\n",
      "dw error:  8.162015570444288e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.22e-08\n",
      "W2 relative error: 3.48e-10\n",
      "b1 relative error: 6.55e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 8.18e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.09e-09\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set.\n",
    "\n",
    "--- \n",
    "Solver 的作用是训练模型，而不是调参  \n",
    "每过一个 epoch 就将学习速率调整一次  \n",
    "每一个 epoch 中的迭代次数由 batch_size 在训练集中的占比确定"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 2440) loss: 2.303875\n",
      "(Epoch 0 / 20) train acc: 0.151000; val_acc: 0.146000\n",
      "(Iteration 101 / 2440) loss: 1.648814\n",
      "(Epoch 1 / 20) train acc: 0.390000; val_acc: 0.416000\n",
      "(Iteration 201 / 2440) loss: 1.596494\n",
      "(Epoch 2 / 20) train acc: 0.488000; val_acc: 0.470000\n",
      "(Iteration 301 / 2440) loss: 1.496337\n",
      "(Epoch 3 / 20) train acc: 0.484000; val_acc: 0.445000\n",
      "(Iteration 401 / 2440) loss: 1.321391\n",
      "(Epoch 4 / 20) train acc: 0.507000; val_acc: 0.474000\n",
      "(Iteration 501 / 2440) loss: 1.327890\n",
      "(Iteration 601 / 2440) loss: 1.331767\n",
      "(Epoch 5 / 20) train acc: 0.515000; val_acc: 0.503000\n",
      "(Iteration 701 / 2440) loss: 1.282000\n",
      "(Epoch 6 / 20) train acc: 0.529000; val_acc: 0.515000\n",
      "(Iteration 801 / 2440) loss: 1.149946\n",
      "(Epoch 7 / 20) train acc: 0.567000; val_acc: 0.494000\n",
      "(Iteration 901 / 2440) loss: 1.303060\n",
      "(Epoch 8 / 20) train acc: 0.565000; val_acc: 0.514000\n",
      "(Iteration 1001 / 2440) loss: 1.166435\n",
      "(Epoch 9 / 20) train acc: 0.588000; val_acc: 0.529000\n",
      "(Iteration 1101 / 2440) loss: 1.248509\n",
      "(Iteration 1201 / 2440) loss: 1.232033\n",
      "(Epoch 10 / 20) train acc: 0.599000; val_acc: 0.508000\n",
      "(Iteration 1301 / 2440) loss: 1.189771\n",
      "(Epoch 11 / 20) train acc: 0.610000; val_acc: 0.543000\n",
      "(Iteration 1401 / 2440) loss: 1.072381\n",
      "(Epoch 12 / 20) train acc: 0.604000; val_acc: 0.535000\n",
      "(Iteration 1501 / 2440) loss: 1.219574\n",
      "(Epoch 13 / 20) train acc: 0.607000; val_acc: 0.523000\n",
      "(Iteration 1601 / 2440) loss: 1.224184\n",
      "(Iteration 1701 / 2440) loss: 1.076106\n",
      "(Epoch 14 / 20) train acc: 0.620000; val_acc: 0.520000\n",
      "(Iteration 1801 / 2440) loss: 1.024133\n",
      "(Epoch 15 / 20) train acc: 0.592000; val_acc: 0.523000\n",
      "(Iteration 1901 / 2440) loss: 1.090859\n",
      "(Epoch 16 / 20) train acc: 0.650000; val_acc: 0.529000\n",
      "(Iteration 2001 / 2440) loss: 1.044584\n",
      "(Epoch 17 / 20) train acc: 0.623000; val_acc: 0.539000\n",
      "(Iteration 2101 / 2440) loss: 1.017646\n",
      "(Epoch 18 / 20) train acc: 0.665000; val_acc: 0.540000\n",
      "(Iteration 2201 / 2440) loss: 0.955345\n",
      "(Iteration 2301 / 2440) loss: 1.080513\n",
      "(Epoch 19 / 20) train acc: 0.656000; val_acc: 0.544000\n",
      "(Iteration 2401 / 2440) loss: 1.103811\n",
      "(Epoch 20 / 20) train acc: 0.638000; val_acc: 0.534000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet(hidden_dim=300, reg=1e-3)\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "solver = Solver(model, data, update_rule='sgd', optim_config={'learning_rate':1.2e-3,},\n",
    "                lr_decay=0.95, num_epochs=20, batch_size=400, print_every=100)\n",
    "solver.train()\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "W1 relative error: 1.48e-07\n",
      "W2 relative error: 2.21e-05\n",
      "W3 relative error: 3.53e-07\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "W1 relative error: 7.36e-09\n",
      "W2 relative error: 6.87e-08\n",
      "W3 relative error: 3.48e-08\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.80e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs.\n",
    "\n",
    "---\n",
    "weight_scale 影响的是 W 初始分布（随机标准差）  \n",
    "本题降低 learning_rate 即可"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.363364\n",
      "(Epoch 0 / 20) train acc: 0.180000; val_acc: 0.108000\n",
      "(Epoch 1 / 20) train acc: 0.320000; val_acc: 0.127000\n",
      "(Epoch 2 / 20) train acc: 0.440000; val_acc: 0.172000\n",
      "(Epoch 3 / 20) train acc: 0.500000; val_acc: 0.184000\n",
      "(Epoch 4 / 20) train acc: 0.540000; val_acc: 0.181000\n",
      "(Epoch 5 / 20) train acc: 0.740000; val_acc: 0.190000\n",
      "(Iteration 11 / 40) loss: 0.839976\n",
      "(Epoch 6 / 20) train acc: 0.740000; val_acc: 0.187000\n",
      "(Epoch 7 / 20) train acc: 0.740000; val_acc: 0.183000\n",
      "(Epoch 8 / 20) train acc: 0.820000; val_acc: 0.177000\n",
      "(Epoch 9 / 20) train acc: 0.860000; val_acc: 0.200000\n",
      "(Epoch 10 / 20) train acc: 0.920000; val_acc: 0.191000\n",
      "(Iteration 21 / 40) loss: 0.337174\n",
      "(Epoch 11 / 20) train acc: 0.960000; val_acc: 0.189000\n",
      "(Epoch 12 / 20) train acc: 0.940000; val_acc: 0.180000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.199000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.199000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.195000\n",
      "(Iteration 31 / 40) loss: 0.075911\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.182000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.201000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.207000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.185000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.192000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 1e-2   # Experiment with this!\n",
    "learning_rate = 1e-2  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs.\n",
    "\n",
    "--- \n",
    "本题通过增大 weight_scale 可达到模型收敛的目的，为什么？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.839886\n",
      "(Epoch 0 / 20) train acc: 0.220000; val_acc: 0.111000\n",
      "(Epoch 1 / 20) train acc: 0.240000; val_acc: 0.084000\n",
      "(Epoch 2 / 20) train acc: 0.420000; val_acc: 0.137000\n",
      "(Epoch 3 / 20) train acc: 0.440000; val_acc: 0.128000\n",
      "(Epoch 4 / 20) train acc: 0.700000; val_acc: 0.148000\n",
      "(Epoch 5 / 20) train acc: 0.740000; val_acc: 0.150000\n",
      "(Iteration 11 / 40) loss: 0.985188\n",
      "(Epoch 6 / 20) train acc: 0.780000; val_acc: 0.166000\n",
      "(Epoch 7 / 20) train acc: 0.900000; val_acc: 0.178000\n",
      "(Epoch 8 / 20) train acc: 0.940000; val_acc: 0.166000\n",
      "(Epoch 9 / 20) train acc: 0.940000; val_acc: 0.169000\n",
      "(Epoch 10 / 20) train acc: 0.900000; val_acc: 0.185000\n",
      "(Iteration 21 / 40) loss: 0.360608\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.182000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.188000\n",
      "(Epoch 13 / 20) train acc: 0.980000; val_acc: 0.200000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.188000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.179000\n",
      "(Iteration 31 / 40) loss: 0.075659\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.185000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.193000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.189000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.186000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.180000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 2e-2  # Experiment with this!\n",
    "weight_scale = 4e-2   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "五层网络参数多，模型复杂，容易陷入局部极小值，对初始权重更敏感\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8.\n",
    "\n",
    "--- \n",
    "动量SGD法：速度累积，同时带有阻尼，因此梯度方向不变时可以加速训练，梯度方向改变时可以抑制振荡  \n",
    "公式不太一样？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.559978\n",
      "(Epoch 0 / 5) train acc: 0.104000; val_acc: 0.107000\n",
      "(Iteration 11 / 200) loss: 2.356069\n",
      "(Iteration 21 / 200) loss: 2.214091\n",
      "(Iteration 31 / 200) loss: 2.205928\n",
      "(Epoch 1 / 5) train acc: 0.225000; val_acc: 0.193000\n",
      "(Iteration 41 / 200) loss: 2.132095\n",
      "(Iteration 51 / 200) loss: 2.118950\n",
      "(Iteration 61 / 200) loss: 2.116443\n",
      "(Iteration 71 / 200) loss: 2.132549\n",
      "(Epoch 2 / 5) train acc: 0.298000; val_acc: 0.260000\n",
      "(Iteration 81 / 200) loss: 1.977227\n",
      "(Iteration 91 / 200) loss: 2.007528\n",
      "(Iteration 101 / 200) loss: 2.004762\n",
      "(Iteration 111 / 200) loss: 1.885342\n",
      "(Epoch 3 / 5) train acc: 0.343000; val_acc: 0.287000\n",
      "(Iteration 121 / 200) loss: 1.891517\n",
      "(Iteration 131 / 200) loss: 1.923677\n",
      "(Iteration 141 / 200) loss: 1.957744\n",
      "(Iteration 151 / 200) loss: 1.966736\n",
      "(Epoch 4 / 5) train acc: 0.322000; val_acc: 0.305000\n",
      "(Iteration 161 / 200) loss: 1.801483\n",
      "(Iteration 171 / 200) loss: 1.973779\n",
      "(Iteration 181 / 200) loss: 1.666572\n",
      "(Iteration 191 / 200) loss: 1.909494\n",
      "(Epoch 5 / 5) train acc: 0.372000; val_acc: 0.319000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 3.153778\n",
      "(Epoch 0 / 5) train acc: 0.099000; val_acc: 0.088000\n",
      "(Iteration 11 / 200) loss: 2.227203\n",
      "(Iteration 21 / 200) loss: 2.125322\n",
      "(Iteration 31 / 200) loss: 1.933623\n",
      "(Epoch 1 / 5) train acc: 0.300000; val_acc: 0.259000\n",
      "(Iteration 41 / 200) loss: 1.951480\n",
      "(Iteration 51 / 200) loss: 1.778344\n",
      "(Iteration 61 / 200) loss: 1.759060\n",
      "(Iteration 71 / 200) loss: 1.865580\n",
      "(Epoch 2 / 5) train acc: 0.391000; val_acc: 0.325000\n",
      "(Iteration 81 / 200) loss: 1.997256\n",
      "(Iteration 91 / 200) loss: 1.675952\n",
      "(Iteration 101 / 200) loss: 1.539517\n",
      "(Iteration 111 / 200) loss: 1.437328\n",
      "(Epoch 3 / 5) train acc: 0.473000; val_acc: 0.340000\n",
      "(Iteration 121 / 200) loss: 1.660325\n",
      "(Iteration 131 / 200) loss: 1.495063\n",
      "(Iteration 141 / 200) loss: 1.632314\n",
      "(Iteration 151 / 200) loss: 1.686809\n",
      "(Epoch 4 / 5) train acc: 0.495000; val_acc: 0.337000\n",
      "(Iteration 161 / 200) loss: 1.495090\n",
      "(Iteration 171 / 200) loss: 1.432442\n",
      "(Iteration 181 / 200) loss: 1.364615\n",
      "(Iteration 191 / 200) loss: 1.294965\n",
      "(Epoch 5 / 5) train acc: 0.539000; val_acc: 0.368000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/victorbian/.conda/envs/cs231n/lib/python3.7/site-packages/matplotlib/figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-3,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adam 注意点：t 需要预先加一"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  1.1395691798535431e-07\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 3.476928\n",
      "(Epoch 0 / 5) train acc: 0.126000; val_acc: 0.110000\n",
      "(Iteration 11 / 200) loss: 2.027712\n",
      "(Iteration 21 / 200) loss: 2.183358\n",
      "(Iteration 31 / 200) loss: 1.744257\n",
      "(Epoch 1 / 5) train acc: 0.363000; val_acc: 0.330000\n",
      "(Iteration 41 / 200) loss: 1.707951\n",
      "(Iteration 51 / 200) loss: 1.703835\n",
      "(Iteration 61 / 200) loss: 2.094758\n",
      "(Iteration 71 / 200) loss: 1.505558\n",
      "(Epoch 2 / 5) train acc: 0.419000; val_acc: 0.362000\n",
      "(Iteration 81 / 200) loss: 1.594429\n",
      "(Iteration 91 / 200) loss: 1.519017\n",
      "(Iteration 101 / 200) loss: 1.368522\n",
      "(Iteration 111 / 200) loss: 1.470400\n",
      "(Epoch 3 / 5) train acc: 0.460000; val_acc: 0.378000\n",
      "(Iteration 121 / 200) loss: 1.199064\n",
      "(Iteration 131 / 200) loss: 1.464704\n",
      "(Iteration 141 / 200) loss: 1.359863\n",
      "(Iteration 151 / 200) loss: 1.415068\n",
      "(Epoch 4 / 5) train acc: 0.521000; val_acc: 0.374000\n",
      "(Iteration 161 / 200) loss: 1.382818\n",
      "(Iteration 171 / 200) loss: 1.359900\n",
      "(Iteration 181 / 200) loss: 1.095948\n",
      "(Iteration 191 / 200) loss: 1.243088\n",
      "(Epoch 5 / 5) train acc: 0.573000; val_acc: 0.382000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.589166\n",
      "(Epoch 0 / 5) train acc: 0.119000; val_acc: 0.146000\n",
      "(Iteration 11 / 200) loss: 2.032921\n",
      "(Iteration 21 / 200) loss: 1.897278\n",
      "(Iteration 31 / 200) loss: 1.770793\n",
      "(Epoch 1 / 5) train acc: 0.381000; val_acc: 0.320000\n",
      "(Iteration 41 / 200) loss: 1.895732\n",
      "(Iteration 51 / 200) loss: 1.681091\n",
      "(Iteration 61 / 200) loss: 1.487204\n",
      "(Iteration 71 / 200) loss: 1.629973\n",
      "(Epoch 2 / 5) train acc: 0.429000; val_acc: 0.350000\n",
      "(Iteration 81 / 200) loss: 1.506686\n",
      "(Iteration 91 / 200) loss: 1.610742\n",
      "(Iteration 101 / 200) loss: 1.486124\n",
      "(Iteration 111 / 200) loss: 1.559454\n",
      "(Epoch 3 / 5) train acc: 0.492000; val_acc: 0.359000\n",
      "(Iteration 121 / 200) loss: 1.496860\n",
      "(Iteration 131 / 200) loss: 1.531552\n",
      "(Iteration 141 / 200) loss: 1.550195\n",
      "(Iteration 151 / 200) loss: 1.657838\n",
      "(Epoch 4 / 5) train acc: 0.533000; val_acc: 0.354000\n",
      "(Iteration 161 / 200) loss: 1.603105\n",
      "(Iteration 171 / 200) loss: 1.405372\n",
      "(Iteration 181 / 200) loss: 1.503740\n",
      "(Iteration 191 / 200) loss: 1.385278\n",
      "(Epoch 5 / 5) train acc: 0.531000; val_acc: 0.374000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "AdaGrad 累积梯度平方作为学习率的分母，会导致学习率过快下降（AdaGrad 是否有加快学习速度的作用？）  \n",
    "Adam 不存在该问题，因为它用的是指数加权平均\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 12250) loss: 2.345061\n",
      "(Epoch 0 / 25) train acc: 0.089000; val_acc: 0.104000\n",
      "(Iteration 101 / 12250) loss: 2.089068\n",
      "(Iteration 201 / 12250) loss: 1.928513\n",
      "(Iteration 301 / 12250) loss: 1.764669\n",
      "(Iteration 401 / 12250) loss: 1.879349\n",
      "(Epoch 1 / 25) train acc: 0.380000; val_acc: 0.363000\n",
      "(Iteration 501 / 12250) loss: 1.742142\n",
      "(Iteration 601 / 12250) loss: 1.677193\n",
      "(Iteration 701 / 12250) loss: 1.850641\n",
      "(Iteration 801 / 12250) loss: 1.801563\n",
      "(Iteration 901 / 12250) loss: 1.662954\n",
      "(Epoch 2 / 25) train acc: 0.416000; val_acc: 0.428000\n",
      "(Iteration 1001 / 12250) loss: 1.799032\n",
      "(Iteration 1101 / 12250) loss: 1.568875\n",
      "(Iteration 1201 / 12250) loss: 1.540661\n",
      "(Iteration 1301 / 12250) loss: 1.534987\n",
      "(Iteration 1401 / 12250) loss: 1.567245\n",
      "(Epoch 3 / 25) train acc: 0.458000; val_acc: 0.456000\n",
      "(Iteration 1501 / 12250) loss: 1.540166\n",
      "(Iteration 1601 / 12250) loss: 1.688543\n",
      "(Iteration 1701 / 12250) loss: 1.655826\n",
      "(Iteration 1801 / 12250) loss: 1.532346\n",
      "(Iteration 1901 / 12250) loss: 1.622891\n",
      "(Epoch 4 / 25) train acc: 0.471000; val_acc: 0.481000\n",
      "(Iteration 2001 / 12250) loss: 1.542100\n",
      "(Iteration 2101 / 12250) loss: 1.736360\n",
      "(Iteration 2201 / 12250) loss: 1.444231\n",
      "(Iteration 2301 / 12250) loss: 1.550931\n",
      "(Iteration 2401 / 12250) loss: 1.702432\n",
      "(Epoch 5 / 25) train acc: 0.516000; val_acc: 0.494000\n",
      "(Iteration 2501 / 12250) loss: 1.592125\n",
      "(Iteration 2601 / 12250) loss: 1.644933\n",
      "(Iteration 2701 / 12250) loss: 1.582394\n",
      "(Iteration 2801 / 12250) loss: 1.451664\n",
      "(Iteration 2901 / 12250) loss: 1.677444\n",
      "(Epoch 6 / 25) train acc: 0.511000; val_acc: 0.490000\n",
      "(Iteration 3001 / 12250) loss: 1.543939\n",
      "(Iteration 3101 / 12250) loss: 1.512602\n",
      "(Iteration 3201 / 12250) loss: 1.440540\n",
      "(Iteration 3301 / 12250) loss: 1.579365\n",
      "(Iteration 3401 / 12250) loss: 1.466912\n",
      "(Epoch 7 / 25) train acc: 0.504000; val_acc: 0.505000\n",
      "(Iteration 3501 / 12250) loss: 1.588828\n",
      "(Iteration 3601 / 12250) loss: 1.408222\n",
      "(Iteration 3701 / 12250) loss: 1.695377\n",
      "(Iteration 3801 / 12250) loss: 1.578150\n",
      "(Iteration 3901 / 12250) loss: 1.659275\n",
      "(Epoch 8 / 25) train acc: 0.550000; val_acc: 0.499000\n",
      "(Iteration 4001 / 12250) loss: 1.389420\n",
      "(Iteration 4101 / 12250) loss: 1.589906\n",
      "(Iteration 4201 / 12250) loss: 1.418817\n",
      "(Iteration 4301 / 12250) loss: 1.533366\n",
      "(Iteration 4401 / 12250) loss: 1.464108\n",
      "(Epoch 9 / 25) train acc: 0.515000; val_acc: 0.516000\n",
      "(Iteration 4501 / 12250) loss: 1.453214\n",
      "(Iteration 4601 / 12250) loss: 1.273967\n",
      "(Iteration 4701 / 12250) loss: 1.479165\n",
      "(Iteration 4801 / 12250) loss: 1.413197\n",
      "(Epoch 10 / 25) train acc: 0.536000; val_acc: 0.520000\n",
      "(Iteration 4901 / 12250) loss: 1.532390\n",
      "(Iteration 5001 / 12250) loss: 1.506853\n",
      "(Iteration 5101 / 12250) loss: 1.674460\n",
      "(Iteration 5201 / 12250) loss: 1.383945\n",
      "(Iteration 5301 / 12250) loss: 1.508652\n",
      "(Epoch 11 / 25) train acc: 0.541000; val_acc: 0.520000\n",
      "(Iteration 5401 / 12250) loss: 1.342294\n",
      "(Iteration 5501 / 12250) loss: 1.428317\n",
      "(Iteration 5601 / 12250) loss: 1.579240\n",
      "(Iteration 5701 / 12250) loss: 1.500541\n",
      "(Iteration 5801 / 12250) loss: 1.481788\n",
      "(Epoch 12 / 25) train acc: 0.572000; val_acc: 0.516000\n",
      "(Iteration 5901 / 12250) loss: 1.344399\n",
      "(Iteration 6001 / 12250) loss: 1.515531\n",
      "(Iteration 6101 / 12250) loss: 1.463585\n",
      "(Iteration 6201 / 12250) loss: 1.687003\n",
      "(Iteration 6301 / 12250) loss: 1.524477\n",
      "(Epoch 13 / 25) train acc: 0.577000; val_acc: 0.527000\n",
      "(Iteration 6401 / 12250) loss: 1.427306\n",
      "(Iteration 6501 / 12250) loss: 1.411318\n",
      "(Iteration 6601 / 12250) loss: 1.539066\n",
      "(Iteration 6701 / 12250) loss: 1.545486\n",
      "(Iteration 6801 / 12250) loss: 1.504882\n",
      "(Epoch 14 / 25) train acc: 0.598000; val_acc: 0.531000\n",
      "(Iteration 6901 / 12250) loss: 1.488135\n",
      "(Iteration 7001 / 12250) loss: 1.333487\n",
      "(Iteration 7101 / 12250) loss: 1.499511\n",
      "(Iteration 7201 / 12250) loss: 1.395728\n",
      "(Iteration 7301 / 12250) loss: 1.525418\n",
      "(Epoch 15 / 25) train acc: 0.574000; val_acc: 0.537000\n",
      "(Iteration 7401 / 12250) loss: 1.409453\n",
      "(Iteration 7501 / 12250) loss: 1.508290\n",
      "(Iteration 7601 / 12250) loss: 1.418430\n",
      "(Iteration 7701 / 12250) loss: 1.310210\n",
      "(Iteration 7801 / 12250) loss: 1.395858\n",
      "(Epoch 16 / 25) train acc: 0.579000; val_acc: 0.527000\n",
      "(Iteration 7901 / 12250) loss: 1.418026\n",
      "(Iteration 8001 / 12250) loss: 1.428409\n",
      "(Iteration 8101 / 12250) loss: 1.379820\n",
      "(Iteration 8201 / 12250) loss: 1.260703\n",
      "(Iteration 8301 / 12250) loss: 1.262743\n",
      "(Epoch 17 / 25) train acc: 0.599000; val_acc: 0.540000\n",
      "(Iteration 8401 / 12250) loss: 1.562140\n",
      "(Iteration 8501 / 12250) loss: 1.430441\n",
      "(Iteration 8601 / 12250) loss: 1.426642\n",
      "(Iteration 8701 / 12250) loss: 1.394443\n",
      "(Iteration 8801 / 12250) loss: 1.398304\n",
      "(Epoch 18 / 25) train acc: 0.575000; val_acc: 0.536000\n",
      "(Iteration 8901 / 12250) loss: 1.388084\n",
      "(Iteration 9001 / 12250) loss: 1.317336\n",
      "(Iteration 9101 / 12250) loss: 1.470493\n",
      "(Iteration 9201 / 12250) loss: 1.487331\n",
      "(Iteration 9301 / 12250) loss: 1.308775\n",
      "(Epoch 19 / 25) train acc: 0.609000; val_acc: 0.545000\n",
      "(Iteration 9401 / 12250) loss: 1.396776\n",
      "(Iteration 9501 / 12250) loss: 1.335746\n",
      "(Iteration 9601 / 12250) loss: 1.424552\n",
      "(Iteration 9701 / 12250) loss: 1.611758\n",
      "(Epoch 20 / 25) train acc: 0.600000; val_acc: 0.541000\n",
      "(Iteration 9801 / 12250) loss: 1.252734\n",
      "(Iteration 9901 / 12250) loss: 1.148527\n",
      "(Iteration 10001 / 12250) loss: 1.344672\n",
      "(Iteration 10101 / 12250) loss: 1.500406\n",
      "(Iteration 10201 / 12250) loss: 1.299106\n",
      "(Epoch 21 / 25) train acc: 0.592000; val_acc: 0.554000\n",
      "(Iteration 10301 / 12250) loss: 1.319949\n",
      "(Iteration 10401 / 12250) loss: 1.485040\n",
      "(Iteration 10501 / 12250) loss: 1.213495\n",
      "(Iteration 10601 / 12250) loss: 1.365268\n",
      "(Iteration 10701 / 12250) loss: 1.521230\n",
      "(Epoch 22 / 25) train acc: 0.636000; val_acc: 0.546000\n",
      "(Iteration 10801 / 12250) loss: 1.475733\n",
      "(Iteration 10901 / 12250) loss: 1.316971\n",
      "(Iteration 11001 / 12250) loss: 1.341382\n",
      "(Iteration 11101 / 12250) loss: 1.503037\n",
      "(Iteration 11201 / 12250) loss: 1.303201\n",
      "(Epoch 23 / 25) train acc: 0.609000; val_acc: 0.542000\n",
      "(Iteration 11301 / 12250) loss: 1.204779\n",
      "(Iteration 11401 / 12250) loss: 1.454334\n",
      "(Iteration 11501 / 12250) loss: 1.377772\n",
      "(Iteration 11601 / 12250) loss: 1.390332\n",
      "(Iteration 11701 / 12250) loss: 1.298444\n",
      "(Epoch 24 / 25) train acc: 0.612000; val_acc: 0.544000\n",
      "(Iteration 11801 / 12250) loss: 1.576736\n",
      "(Iteration 11901 / 12250) loss: 1.267343\n",
      "(Iteration 12001 / 12250) loss: 1.247942\n",
      "(Iteration 12101 / 12250) loss: 1.513582\n",
      "(Iteration 12201 / 12250) loss: 1.536918\n",
      "(Epoch 25 / 25) train acc: 0.635000; val_acc: 0.566000\n"
     ]
    }
   ],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "model = FullyConnectedNet([300, 300, 300, 300], dropout=0.5, normalization='batchnorm', reg=0.0, weight_scale=1e-2)\n",
    "solver = Solver(model, data, num_epochs=25, batch_size=100, update_rule='adam', optim_config={'learning_rate': 1e-4}, verbose=True, print_every=100)\n",
    "solver.train()\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_model = model\n",
    "\n",
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
